home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Extra 1997 #2 / Amiga Plus Extra 1997 #2.iso / system / dsound / source.lha / PlayMono.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-18  |  4.2 KB  |  190 lines
  1.  
  2. /*************************************************************************/
  3. /*                   PlayMono.c                 */
  4. /*           Contains code used to play mono samples.          */
  5. /*************************************************************************/
  6.  
  7. #include <exec/types.h>
  8. #include <exec/exec.h>
  9. #include <devices/audio.h>
  10. #include <dos/dos.h>
  11. #include <intuition/intuition.h>
  12. #include <intuition/intuitionbase.h>
  13. #include <graphics/gfxbase.h>
  14. #include <stdlib.h>
  15.  
  16. #include "dsound.h"
  17. #include "minrexx.h"
  18.  
  19. #include <proto/intuition.h>
  20. #include <proto/exec.h>
  21. #include <proto/dos.h>
  22.  
  23. UBYTE rightAMap[]={4,2,1,8};
  24. UBYTE leftAMap[]={1,8,2,4};
  25. UBYTE eitherAMap[]={1,2,4,8};
  26. UBYTE bothAMap[]={8,3,5,10};
  27.  
  28. extern UBYTE volume;
  29. extern UWORD speed;
  30. extern ULONG bufSize;
  31.  
  32. extern BOOL readAll;
  33. extern BOOL loop;
  34. extern struct Window *window;
  35.  
  36. extern ULONG signalMask;
  37.  
  38. extern BOOL rexxAbort;
  39.  
  40. /*Play a sample out of one speaker (left, right, or either)*/
  41. void playMonoSample(BPTR file,channel audioChannel,struct Voice8Header *vhdr,
  42.             ULONG len)
  43. {
  44.    struct IOAudio *iob1,*iob2,*curIob,*altIob;
  45.    extern long arexxSigBit;
  46.    ULONG toRead;
  47.    ULONG sampleSize=len;
  48.    ULONG amountLeft;
  49.    BOOL done=FALSE;
  50.    UBYTE *allocationMap;
  51.  
  52.    /*Load the entire sample into memory, if the user so specified*/
  53.    if(readAll)
  54.    {
  55.       storeLeft(file,len,bufSize);
  56.       file=0L;
  57.    }
  58.  
  59.    /*Decide which audio channel will be allocated*/
  60.    switch(audioChannel)
  61.    {
  62.       case MONO_LEFT:
  63.      allocationMap=leftAMap;
  64.      break;
  65.       case MONO_RIGHT:
  66.      allocationMap=rightAMap;
  67.      break;
  68.       case UNSPECIFIED:
  69.      allocationMap=eitherAMap;
  70.      break;
  71.    }
  72.  
  73.    /*Get the first audio channel*/
  74.    iob1=GetAudioChannel(bufSize,allocationMap);
  75.    if(iob1==NULL)
  76.    {
  77.       WriteMsg("Couldn't create the first buffer\n");
  78.       cleanup(150);
  79.    }
  80.  
  81.    /* If the user didn't specify a volume, get it from the VHDR */
  82.    if(volume==0)
  83.       volume=(vhdr->volume>>10);
  84.  
  85.    /* If the VHDR gave a volume of zero, use maximum volume*/
  86.    if(volume==0)
  87.       volume=64;
  88.  
  89.    /* Get the samples/sec rate (either the rate given by the user, or the*/
  90.    /* rate found in the VHDR) */
  91.    if(speed==0)
  92.       speed=1000000000/(vhdr->samplesPerSec*279);
  93.    else
  94.       speed=1000000000/(speed*279);
  95.  
  96.    InitAudioChannel(iob1,volume,speed);
  97.  
  98.    /*Get the 2nd audio channel*/
  99.    iob2=DuplicateAudioChannel(iob1);
  100.  
  101.    if(iob2==NULL)
  102.    {
  103.       FreeAudioChannel(iob1);
  104.       WriteMsg("Couldn't create the second buffer\n");
  105.       cleanup(175);
  106.    }
  107.  
  108.    /* Load the first buffer*/
  109.    toRead=MIN(len,bufSize);
  110.    LoadAudioBuffer(file,iob1,toRead);
  111.  
  112.    len-=toRead;
  113.    if(len==0 && loop)
  114.    {
  115.       len=sampleSize;
  116.       if(!readAll)
  117.      Seek(file,-sampleSize,OFFSET_CURRENT);
  118.    }
  119.  
  120.    /*Store the number of samples to be played*/
  121.    iob1->ioa_Length=toRead;
  122.  
  123.    updateSampleInfo(0,sampleSize,vhdr->samplesPerSec);
  124.  
  125.    /*Queue up the play request*/
  126.    BeginIO((struct IORequest *)iob1);
  127.  
  128.    curIob=iob2;
  129.    altIob=iob1;
  130.  
  131.    /*Loop while there's stuff to read*/
  132.    while(!done && !rexxAbort)
  133.    {
  134.       toRead=MIN(len,bufSize);
  135.       if(toRead!=0)
  136.       {
  137.      LoadAudioBuffer(file,curIob,toRead);
  138.      curIob->ioa_Length=toRead;
  139.      BeginIO((struct IORequest *)curIob);
  140.      amountLeft=len-=toRead;
  141.      if(len==0 && loop)
  142.      {
  143.         len=sampleSize;
  144.         if(!readAll)
  145.            Seek(file,-sampleSize,OFFSET_CURRENT);
  146.      }
  147.      done=FALSE;
  148.       }
  149.       else
  150.      done=TRUE;
  151.  
  152.       /*Wait for the buffer to finish*/
  153.       if((Wait((1<<altIob->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit) |
  154.        signalMask | arexxSigBit) & SIGBREAKF_CTRL_C) == SIGBREAKF_CTRL_C)
  155.      done=TRUE;
  156.  
  157.       dispRexxPort();
  158.  
  159.       /*Update the sample position info*/
  160.       updateSampleInfo(sampleSize-amountLeft-toRead,sampleSize,vhdr->samplesPerSec);
  161.       if(window!=NULL && GetMsg(window->UserPort)!=NULL)
  162.       {
  163.      done=TRUE;
  164.       }
  165.  
  166.       swapPointers(&curIob,&altIob);
  167.    }
  168.  
  169.    /*Restore the buffer lengths, so that FreeAudio() channel, etc., knows*/
  170.    /*how much memory to free*/
  171.    iob1->ioa_Length=iob2->ioa_Length=bufSize;
  172.  
  173.    FreeAudioChannel(iob1);
  174.    DeleteDuplication(iob2);
  175.  
  176.    return;
  177. }
  178.  
  179. void swapPointers(struct IOAudio **first,struct IOAudio **second)
  180. {
  181.    void *temp;
  182.  
  183.    temp=*first;
  184.    *first=*second;
  185.    *second=temp;
  186.  
  187.    return;
  188. }
  189. /*End of PlayMono.c*/
  190.